home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / program / pdmake.arc / STSTUFF.C < prev    next >
C/C++ Source or Header  |  1986-12-15  |  7KB  |  346 lines
  1.     /***************************************************************\
  2.     *                                *
  3.     *  PDMAKE, Atari ST version                    *
  4.     *                                *
  5.     *  Adapted from mod.sources Vol 7 Issue 71, 1986-12-03.        *
  6.     *                                *
  7.     *  This port makes extensive use of the original net.sources    *
  8.     *  port by Jwahar Bammi.                    *
  9.     *                                *
  10.     *      Ton van Overbeek                        *
  11.     *      Email: TPC862@ESTEC.BITNET                *
  12.     *             TPC862%ESTEC.BITNET@WISCVM.WISC.EDU    (ARPA)    *
  13.     *             ...!mcvax!tpc862%estec.bitnet   (UUCP Europe)    *
  14.     *             ...!ucbvax!tpc862%estec.bitnet  (UUCP U.S.A.)    *
  15.     *             71450,3537  (CompuServe)                *
  16.     *                                *
  17.     \***************************************************************/
  18.  
  19. /*
  20.  *
  21.  * ststuff.c - Retrofit routines
  22.  *             for the Atari St's
  23.  *
  24.  */
  25.  
  26. #ifdef ATARIST
  27. #include <stdio.h>
  28. #include <ctype.h>
  29. #include "h.h"
  30. #include "astat.h"
  31.  
  32. /*
  33.  * Get file statistics - sort of like stat(2)
  34.  */
  35.  
  36. int getstat(fname, buf)
  37. register char *fname;
  38. register struct stat *buf;
  39. {
  40.     register struct stat *save_dta;
  41.     register int status;
  42.  
  43.     /* Save old DTA */
  44.     save_dta = (struct stat *)Fgetdta();
  45.  
  46.     /* set the new DTA */
  47.     Fsetdta(buf);
  48.  
  49.     /* Find file stat */
  50.     status = Fsfirst(fname, 0);
  51.  
  52.     /* reset dta */
  53.     Fsetdta(save_dta);
  54.  
  55.     /* return status */
  56.     return (status == 0) ? 0 : -1;
  57.  
  58. }
  59.  
  60.  
  61. /*
  62.  * system - execute a command and return status
  63.  */
  64. int system(cmd)
  65. register char *cmd;
  66. {
  67.     char command[128], tail[130];
  68.     register char *p, *save;
  69.     register int n;
  70.  
  71.     if(*cmd == '%')
  72.         /* Atari special internal command */
  73.         return st_special(cmd);
  74.  
  75.     /* Break up command into command and command tail */
  76.     for(p = save = command; !isspace(*cmd); *p++ = *cmd++)    /* copy */;
  77.     *p = '\0';
  78.  
  79.     while(isspace(*cmd)) cmd++;                /* skip blanks */
  80.     if((n = strlen(cmd)) > 128)
  81.     {
  82.         fprintf(stderr,"Command '%s' too long\n",save);
  83.         return -1;
  84.     }
  85.  
  86.     tail[0] = (char) n;
  87.     strcpy(&tail[1],cmd);
  88.  
  89.     return (int)Pexec(0,command, tail, (char *)NULL);
  90. }
  91.  
  92. /*
  93.  * Atari St special commands
  94.  *
  95.  */
  96. int st_special(cmd)
  97. register char *cmd;
  98. {
  99.     extern int rm(), cp();
  100.  
  101.     switch(cmd[1])
  102.     {
  103.         case 'r':
  104.         case 'R':    /* remove */
  105.         return rm(&cmd[2]);
  106.  
  107.         case 'c':
  108.         case 'C':    /* copy */
  109.         return cp(&cmd[2]);
  110.  
  111.         case 'e':
  112.         case 'E':
  113.         return echo(&cmd[2]);
  114.  
  115.         default:
  116.         fprintf(stderr,"Warning: '%s' - Unknown Atari Special Command\n",
  117.             cmd);
  118.     }
  119.     return 0;
  120. }
  121.  
  122. /*
  123.  * remove file(s)
  124.  *
  125.  */
  126. int rm(list)
  127. register char *list;
  128. {
  129.     char name[128];
  130.     register char *p;
  131.  
  132.     while((!isspace(*list)) && (*list != '\0')) list++;
  133.     while(*list != '\0')
  134.     {
  135.         while(isspace(*list)) list++;
  136.  
  137.         for(p = name; !isspace(*list) && (*list != '\0');
  138.             *p++ = *list++) /* copy */;
  139.         *p = '\0';
  140.  
  141.         if(p != name)
  142.             remove(name);     /* never mind the return value
  143.                       * we are doing 'rm -f'
  144.                       */
  145.     }
  146.     return 0;
  147. }
  148.  
  149.  
  150. #define iswild(F) ((index(F,'*')!=(char *)NULL)||(index(F,'?')!=(char *)NULL))
  151.  
  152. /*
  153.  * this routine actually removes the files, dealing with wildcards
  154.  *
  155.  */
  156. remove(filename)
  157. register char *filename;
  158. {
  159.     register struct stat *save_dta;
  160.     struct stat buf;
  161.     char fbuf[128];
  162.     char pbuf[128];
  163.     register char *path, *p;
  164.     extern char *strcpy(), *strcat(), *index(), *rindex();
  165.  
  166.     if(!iswild(filename))
  167.     {
  168.         /* not a wild card */
  169.         unlink(filename);
  170.         return;
  171.     }
  172.  
  173.     /* Wild Card */
  174.     if((p = rindex(filename,'\\')) != (char *)NULL)
  175.     {
  176.         register char *q;
  177.  
  178.         /* Pick up path */
  179.         p++;
  180.         for(path = pbuf, q= filename; q != p; *path++ = *q++) /* Copy */;
  181.         *path = '\0';
  182.         path = pbuf;
  183.     }
  184.     else
  185.         /* No path */
  186.         path = (char *)NULL;
  187.  
  188.     /* Save old DTA */
  189.     save_dta = (struct stat *)Fgetdta();
  190.  
  191.     /* set the new DTA */
  192.     Fsetdta(&buf);
  193.  
  194.     /* Unlink the first match for wild card */
  195.     if(Fsfirst(filename, (0x01 | 0x010 | 0x020)) != 0)
  196.         /* No such file(s), simply return */
  197.             return;
  198.  
  199.     unlink ( (path == (char *)NULL) ? buf.st_sp2
  200.           : strcat(strcpy(fbuf, path), buf.st_sp2) );
  201.  
  202.     /* Unlink any other match(s) for wild card */
  203.     while(Fsnext() == 0)
  204.         /* rest of them */
  205.         unlink ( (path == (char *)NULL) ? buf.st_sp2
  206.               : strcat(strcpy(fbuf, path), buf.st_sp2) );
  207.  
  208.     /* reset dta */
  209.     Fsetdta(save_dta);
  210. }
  211.  
  212. /*
  213.  * copy files
  214.  *
  215.  */
  216. int cp(list)
  217. register char *list;
  218. {
  219.     char source[128], dest[128];
  220.     char buf[512];
  221.     register char *p;
  222.     register int fsource, fdest;
  223.     register long count;
  224.  
  225.     while((!isspace(*list)) && (*list != '\0')) list++;
  226.     while(isspace(*list)) list++;
  227.     if(*list == '\0')
  228.     {
  229.         /* no source specified */
  230.         fprintf(stderr,"Usage: ${CP} <source file> <destination file>\n");
  231.         return 1;
  232.     }
  233.  
  234.     for(p = source; !isspace(*list) && (*list != '\0'); *p++ = *list++) /* copy */;
  235.     *p = '\0';
  236.  
  237.     while(isspace(*list)) list++;
  238.     if(*list == '\0')
  239.     {
  240.         /* no destination specified */
  241.         fprintf(stderr,"Usage: ${CP} <source file> <destination file>\n");
  242.         return 2;
  243.     }
  244.  
  245.     for(p = dest; !isspace(*list) && (*list != '\0'); *p++ = *list++) /* copy */;
  246.     *p = '\0';
  247.  
  248.     if(*list != 0)
  249.     {
  250.         fprintf(stderr,"Only 2 parameters allowed\nUsage: $(CP) <source file>\
  251.  <destination file>\n");
  252.         return 6;
  253.     }
  254.  
  255.  
  256.     if((fsource = Fopen(source, 0)) < 0)
  257.     {
  258.         fprintf(stderr,"%s: no such file\n", source);
  259.         return 3;
  260.     }
  261.  
  262.     if((fdest = Fcreate(dest, 0)) < 0)
  263.     {
  264.         /* May already exist */
  265.         if((fdest = Fopen(dest, 1)) < 0)
  266.         {
  267.             fprintf(stderr,"%s: cannot open for write\n", dest);
  268.             Fclose(fsource);
  269.             return 4;
  270.         }
  271.     }
  272.  
  273.     while((count = Fread(fsource, 512L, buf)) > 0)
  274.     {
  275.         if(Fwrite(fdest, count, buf) != count)
  276.         {
  277.             fprintf(stderr,"Error writing %s\n", dest);
  278.             Fclose(fsource);
  279.             Fclose(fdest);
  280.             return 5;
  281.         }
  282.     }
  283.  
  284.     Fclose(fsource);
  285.     Fclose(fdest);
  286.  
  287.     return 0;
  288. }
  289.  
  290. /*
  291.  * Echo arguments
  292.  *
  293.  */
  294. int echo(list)
  295. register char *list;
  296. {
  297.     while((!isspace(*list)) && (*list != '\0')) list++;
  298.  
  299.     if(*list != '\0')
  300.     {
  301.         while(isspace(*list)) list++;
  302.         printf("%s\n",list);
  303.     }
  304.  
  305.     return 0;
  306. }
  307.  
  308.  
  309. /*
  310.  * rtime - stuff current time & date into long (ptr passed)
  311.  *
  312.  */
  313. rtime(t)
  314. long *t;
  315. {
  316.  
  317.     *t = Gettime();    /* Ikbd's time */
  318. }
  319.  
  320. /*
  321.  * Flips Word of a long, used to get the date into the Higher order bits,
  322.  * and time into the lower order bits of a long, so that comparisons can
  323.  * later be done using a simple C relational operator.
  324.  *
  325.  */
  326. void
  327. FlipWords(i)
  328. #ifdef MEGAMAX
  329. unsigned i[];
  330. #else
  331. unsigned int i[];
  332. #endif /* MEGAMAX */
  333. {
  334. #ifdef MEGAMAX
  335.     register unsigned  temp;
  336. #else
  337.     register unsigned int temp;
  338. #endif /* MEGAMAX */
  339.  
  340.     temp = i[0];
  341.     i[0] = i[1];
  342.     i[1] = temp;
  343. }
  344.  
  345. #endif /* ATARIST */
  346.